
import java.util.logging.Logger;

import javax.servlet.http.HttpSession;
import groovyx.gaelyk.logging.GroovyLogger;
import groovyx.gaelyk.routes.RedirectionType;

import org.apache.commons.codec.digest.DigestUtils;
import com.google.appengine.api.datastore.*
import src.de.checker.hochzeit.konstanten.*
import src.de.checker.hochzeit.domain.util.*;
import src.de.checker.hochzeit.domain.user.Benachrichtigung;
import src.de.checker.hochzeit.util.*;

import static com.google.appengine.api.datastore.FetchOptions.Builder.*

Logger log = Logger.getLogger('ZugangController');

if(params?.delete ==~ /(?i)true/)
{
	delete();
}
private String getMail()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER)
	def query = new Query(Konstanten.TELEKOMM)
	query.addFilter("gast", Query.FilterOperator.EQUAL, myuser.key.id)
	query.addFilter("typ", Query.FilterOperator.EQUAL, 0)
	PreparedQuery preparedQuery = datastore.prepare(query)
 	def entities = preparedQuery.asList( withLimit(50) )
 	if(entities)
 	{
 		return entities.get(0).wert
 	}
	return ""
}
private void delete()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER)
	if(myuser)
	{
		if(myuser.rolle == 0)
		{
			long t1 = System.currentTimeMillis()
			String hochzeit = myuser.feier
			String username = myuser.vorname+' '+myuser.nachname
			String email = getMail()
			
			Deleted dele = new Deleted()
			dele.user = username
			dele.feier = hochzeit
			dele.email = email
			dele.datum = Datehelper.getNow()
			
			def counter = 0;
			
			log.info("Lösche alle Daten zu Feier "+hochzeit+"...")
			
			//Ansprechpartner löschen
			def query = new Query(Konstanten.ANPRECHPARTNER)
			query.addFilter("feier", Query.FilterOperator.EQUAL, hochzeit)
			PreparedQuery preparedQuery = datastore.prepare(query)
			def entities = preparedQuery.asList( withLimit(300) )
			if(entities)
			{
				int size = entities.size()
				log.info("Anzahl der Ansprechpartner zum Löschen "+size)
				for(i in entities)
				{
					i.delete()
					counter++;
				}
				log.info("Ansprechpartner gelöscht")
			}
			//Anhang löschen
			query = new Query(Konstanten.ANHANG)
			query.addFilter("feier", Query.FilterOperator.EQUAL, hochzeit)
			preparedQuery = datastore.prepare(query)
			entities = preparedQuery.asList( withLimit(300) )
			if(entities)
			{
				size = entities.size()
				log.info("Anzahl der Anhänge zum Löschen "+size)
				for(i in entities)
				{
					i.delete()
					counter++;
				}
				log.info("Anhänge gelöscht")
			}
			//Kinder löschen
			query = new Query(Konstanten.KIND)
			query.addFilter("feier", Query.FilterOperator.EQUAL, hochzeit)
			preparedQuery = datastore.prepare(query)
			entities = preparedQuery.asList( withLimit(300) )
			if(entities)
			{
				size = entities.size()
				log.info("Anzahl der Kinder zum Löschen "+size)
				for(i in entities)
				{
					i.delete()
					counter++;
				}
				log.info("Kinder gelöscht")
			}
			//Budget löschen
			query = new Query(Konstanten.BUDGET)
			query.addFilter("feier", Query.FilterOperator.EQUAL, hochzeit)
			preparedQuery = datastore.prepare(query)
			entities = preparedQuery.asList( withLimit(300) )
			if(entities)
			{
				size = entities.size()
				log.info("Anzahl der Budgeteinträge zum Löschen "+size)
				for(i in entities)
				{
					i.delete()
					counter++;
				}
				log.info("Budgeteinträge gelöscht")
			}
			//Checkliste löschen
			query = new Query(Konstanten.CHECKLISTE)
			query.addFilter("feier", Query.FilterOperator.EQUAL, hochzeit)
			preparedQuery = datastore.prepare(query)
			entities = preparedQuery.asList( withLimit(300) )
			if(entities)
			{
				size = entities.size()
				log.info("Anzahl der Checklisteneinträge zum Löschen "+size)
				for(i in entities)
				{
					i.delete()
					counter++;
				}
				log.info("Checklisteneinträge gelöscht")
			}
			//Hochzeit löschen
			query = new Query(Konstanten.HOCHZEIT)
			query.addFilter("feier", Query.FilterOperator.EQUAL, hochzeit)
			preparedQuery = datastore.prepare(query)
			entities = preparedQuery.asList( withLimit(300) )
			if(entities)
			{
				size = entities.size()
				log.info("Anzahl der Hochzeiten zum Löschen "+size)
				for(i in entities)
				{
					i.delete()
					counter++;
				}
				log.info("Hochzeiten gelöscht")
			}
			//Location löschen
			query = new Query(Konstanten.LOCATION)
			query.addFilter("feier", Query.FilterOperator.EQUAL, hochzeit)
			preparedQuery = datastore.prepare(query)
			entities = preparedQuery.asList( withLimit(300) )
			if(entities)
			{
				size = entities.size()
				log.info("Anzahl der Locations zum Löschen "+size)
				for(i in entities)
				{
					i.feier = "allgemein"
					i.save()
					counter++;
				}
				log.info("Locations gelöscht")
			}
			//Pinnwand löschen
			query = new Query(Konstanten.PINNWAND)
			query.addFilter("hochzeit", Query.FilterOperator.EQUAL, hochzeit)
			preparedQuery = datastore.prepare(query)
			entities = preparedQuery.asList( withLimit(300) )
			if(entities)
			{
				size = entities.size()
				log.info("Anzahl der Pinnwandeinträge zum Löschen "+size)
				for(i in entities)
				{
					i.delete()
					counter++;
				}
				log.info("Pinnwandeinträge gelöscht")
			}
			//Vorschläge löschen
			query = new Query(Konstanten.IDEE)
			query.addFilter("feier", Query.FilterOperator.EQUAL, hochzeit)
			preparedQuery = datastore.prepare(query)
			entities = preparedQuery.asList( withLimit(300) )
			if(entities)
			{
				size = entities.size()
				log.info("Anzahl der Vorschläge zum Löschen "+size)
				for(i in entities)
				{
					i.delete()
					counter++;
				}
				log.info("Vorschläge gelöscht")
			}
			
			query = new Query(Konstanten.GAST)
			query.addFilter("feier", Query.FilterOperator.EQUAL, session.getAttribute(Konstanten.SESSION_USER).feier)
			preparedQuery = datastore.prepare(query)
			entities = preparedQuery.asList( withLimit(300) )
			if(entities)
			{
				size = entities.size()
				log.info("Anzahl der Gäste zum Löschen "+size)
				for(i in entities)
				{
					//Benachrichtigungen löschen
					def userkey = i.key
					def query1 = new Query(Konstanten.BENACHRICHTIGUNG)
					query1.addFilter("gast", Query.FilterOperator.EQUAL, userkey)
					PreparedQuery preparedQuery1 = datastore.prepare(query1)
					def entities1 = preparedQuery1.asList( withLimit(20) )
					for(j in entities1)
					{
						j.delete()
						counter++;
					}
					log.info("Benachrichtigungen gelöscht")
					
					//Telekomm löschen
					query1 = new Query(Konstanten.TELEKOMM)
					query1.addFilter("gast", Query.FilterOperator.EQUAL, userkey.id)
					preparedQuery1 = datastore.prepare(query1)
					entities1 = preparedQuery1.asList( withLimit(20) )
					for(j in entities1)
					{
						j.delete()
						counter++;
					}
					log.info("Telekomm gelöscht")
					i.delete()
					counter++;
				}
				log.info("Gäste gelöscht")
			}
			Entity e = dele as Entity
			e.save()
			
			//TODO: Fotos löschen
			
			long t2 = System.currentTimeMillis()
			log.info("Anzahl aller gelöschten Items: "+counter+" in "+(t2-t1)+" ms")
		}
		else
		{
			createTracer(Konstanten.TRACER_VERBOTEN, "Benutzer versucht sich zu löschen, ist aber kein Brautpaar!")
		}
	}
	else
	{
		log.warning("Kein Nutzer in der session zum löschen")
	}
	
		
	session.user = null;
	session.invalidate();
	redirect '/'
}
private void dologout()
{
	
	if(session != null)
	{ 
	  createTracer(Konstanten.TRACER_LOGOUT,'')
	  session.user = null;
	  session.invalidate();
	  
	}
	redirect '/'
}
private void dologin()
{
	String benutzername = params.benutzername
	String psw = DigestUtils.md5Hex(params.passwort)
	
	def query = new Query(Konstanten.GAST)
	query.addFilter("loginname", Query.FilterOperator.EQUAL, benutzername)
	query.addFilter("passwort", Query.FilterOperator.EQUAL, psw)
	
	PreparedQuery preparedQuery = datastore.prepare(query)
	try
	{
		Entity user = preparedQuery.asSingleEntity()
	
	
	if(user == null)
    {
		request.setAttribute 'message', 'Zugang unbekannt'
		log.warning("Einloggen fehlgeschlagen [Nutzername: "+benutzername+", IP: "+request.getRemoteAddr()+"]")
		forward '/index/index.gtpl'
    }
    else
    {
    	session.setAttribute Konstanten.SESSION_USER, user
		
	    //Hochzeitsdaten suchen und in Session schreiben
	    try
	    {
	    	def queryh = new Query(Konstanten.HOCHZEIT)
			queryh.addFilter("feier", Query.FilterOperator.EQUAL, user.feier)
			PreparedQuery preparedQueryh = datastore.prepare(queryh)
			Entity hochzeit = preparedQueryh.asSingleEntity()
			session.setAttribute Konstanten.SESSION_HOCHZEIT, hochzeit
    	}
	    catch(Exception e){e.printStackTrace()}
	    //Anprechpartner suchen und in Session schreiben
	    try
		{
			def query1 = new Query(Konstanten.ANPRECHPARTNER)
			query1.addFilter("feier", Query.FilterOperator.EQUAL, user.feier)
			PreparedQuery preparedQuery1 = datastore.prepare(query1)
			def entities = preparedQuery1.asList( withLimit(20) )
			session.setAttribute Konstanten.SESSION_ANSP, entities
		}
		catch(Exception e){e.printStackTrace()}
		createTracer(Konstanten.TRACER_LOGIN, '')
		
		//Wenn der Benutzer die Rolle Brautpaar hat, überprüfen ob bereits Objekte für die
		//Benachrichtigung bestehen
		if(user.rolle == 0)
		{
			createbenachr(user)
		}
	    if(user.rolle == 1)
		{
			if(user.benAngelegt == null || !user.benAngelegt)
			{
				createbenachrPlaner(user)
			}
		}
	    redirect '/home/index.gtpl'
       
    }
	}
	catch(Exception e)
	{
		log.warning(e.toString())
		request.message = 'Es gibt Probleme mit dem Zugang. Bitte wende dich an checkerdev@googlemail.com'
		forward '/index/index.gtpl'
	}
	
}
private void createbenachrPlaner(Entity user)
{
	Key userkey = user.key 
	def query = new Query(Konstanten.BENACHRICHTIGUNG)
	query.addFilter("gast", Query.FilterOperator.EQUAL, userkey)
	PreparedQuery preparedQuery = datastore.prepare(query)
	def entities = preparedQuery.asList( withLimit(1) )
	if(entities == null || entities.size() == 0)
	{
		log.info("Neue Benachrichtigungen anlegen für "+userkey+ " (Hochzeitsplaner)")
		
		Benachrichtigung b = new Benachrichtigung()
		b.gast = userkey
		b.wert = true
		b.typ = new Long(6)
		b.tage = new Long(7)
			
		Entity e2 = b as Entity
		e2.save()
			
		log.info("Benachrichtigung anlegt: 6")
		user.benAngelegt = true
		user.save()
	
	}
}

private void createbenachr(Entity user)
{
	Key userkey = user.key 
	def query = new Query(Konstanten.BENACHRICHTIGUNG)
	query.addFilter("gast", Query.FilterOperator.EQUAL, userkey)
	PreparedQuery preparedQuery = datastore.prepare(query)
	def entities = preparedQuery.asList( withLimit(6) )
	if(entities == null || entities.size() == 0)
	{
		log.info("Neue Benachrichtigungen anlegen für "+userkey+ " (Brautpaar)")
		// 1 = Kontakt, 2 = Adresse, 3 = Zusage, 
		// 4 = UpdateKinder, 5 = UpdateAnhang, 6 = Checkliste
		for(int i = 1; i<7; i++)
		{
			Benachrichtigung b = new Benachrichtigung()
			b.gast = userkey
			b.wert = true
			b.typ = new Long(i)
			b.tage = new Long(7)
			
			Entity e2 = b as Entity
			e2.save()
			
			log.info("Benachrichtigung anlegt: "+i)
		}
		user.benAngelegt = true
		user.save()
	}
}

private void createTracer(String message)
{
	createTracer(Konstanten.TRACER_FORGOT, message);
}
private void createTracer(String type, String message) {
	try
	{
		def myuser = session.getAttribute(Konstanten.SESSION_USER);

		Tracer t = new Tracer()
	    t.ipadresse = request.getRemoteAddr()
	    t.user = myuser.key
	    t.type = type
	    t.nachricht = message
	    t.datum = Datehelper.getNow()
	    Entity e2 = t as Entity
		e2.save()
	}
	catch(Exception e)
	{
		
	}
}    